//
// Created by Administrator on 2025/7/31.
//

#ifndef ARRAY_H
#define ARRAY_H
#include <memory>
namespace arrayStudy {
    template<class T>
    class array {
    public:
        /**
         * 定义一个迭代器
         */
        class iterator {
        public:
            explicit iterator(T* ptr=nullptr):_ptr(ptr) {

            }
            bool operator!=(const iterator& it)const {
                return _ptr !=it._ptr;
            }
            void operator++(){
                ++_ptr;
            }
            T& operator*() {
                return *_ptr;
            }
            const T& operator*()const {
                return *_ptr;
            }

        private:
            T* _ptr;
        };
        /**
         *构造函数
         * @param capacity
         */
        explicit array(const int capacity = 10) : _size(0), _capacity(capacity){
            data = new T[capacity];
        }
        /**
         * 析构函数
         */
        ~array() {
            delete[] data;
        }
        iterator begin() {
            return iterator(data);
        }
        iterator end() {
            return iterator(data+_size);
        }

        /**
         *
         * @param arr 拷贝构造函数，不用，主要是为了防止析构出问题
         */
        array(const array &arr) = delete;

        /**
         *
         * @param t 插入一个数据
         */
        void insertData(const T &t) {
            //数组满的话要扩容
            if (_size == _capacity) {
                insert_capacity();
            }
            data[_size++] = t;
        }

        /**
         * 扩容数组
         */
        void insert_capacity() {
            _capacity = _capacity * 2;
            T *newCapacity = new T[_capacity];
            memcpy(newCapacity, data, sizeof(T) * _size);
            delete[] data;
            data = newCapacity;
            std::cout << "add capacity" << std::endl;
        }

        /**
         *
         * @param t 头插一个元素
         */
        void headInsertData(const T &t) {
            //数组满的话要扩容
            if (_size == _capacity) {
                insert_capacity();
            }
            for (int i = _size; i > 0; i--) {
                data[i] = data[i - 1];
            }
            data[0] = t;
            _size++;
        }

        /**
         *
         * @param t 要插入的元素
         * @param position 插入元素的位置
         */
        void insertDataByPosition(const T &t, const int position) {
            if (position < 0 || position > _size) {
                return;
            }
            if (position == 0) {
                headInsertData(t);
                return;
            }
            if (position == _size) {
                insertData(t);
                return;
            }
            if (_size == _capacity) {
                insert_capacity();
            }
            for (int i = _size; i >= position; i--) {
                data[i] = data[i - 1];
            }
            data[position - 1] = t;
            _size++;
        }

        /**
         *
         * @param t 查询一个元素
         * @return
         */
        int selectData(const T &t) {
            for (int i = 0; i < _size; i++) {
                if (data[i] == t) {
                    return i;
                }
            }
            return -1;
        }

        /**
         *
         * @param t 删除一个元素
         */
        void deleteData(const T &t) {
            const int index = selectData(t);
            if (index == -1) {
                return;
            }
            if (index == _size - 1) {
                _size--;
                return;
            }
            if (index < _size - 1) {
                for (int i = index; i < _size - 1; ++i) {
                    data[i] = data[i + 1];
                }
                --_size;
            }
        }

        /**
         *
         * @param position 删除指定位置的元素
         */
        void deleteDataByPosition(const int position) {
            if (position < 0 || position >= _size)
                return;
            for (int i = position - 1; i < _size - 1; ++i) {
                data[i] = data[i + 1];
            }
            --_size;
        }

        /**
         *
         * @return 数组的大小
         */
        int size() const {
            return _size;
        }

        /**
         *
         * @return 数组的容量
         */
        int capacity() const {
            return _capacity;
        }

        /**
         * 反转数组
         */
        void reverseArray() {
            T *left = data;
            T *right = left + _size;
            while (left < right) {
                T temp = *left;
                *left = *right;
                *right = temp;
                ++left;
                --right;
            }
        }
        void show() {
            if (_size == 0) {
                return;
            }
            for (int i = 0; i < _size; i++) {
                std::cout << data[i] << "   ";
            }
            std::cout << std::endl;
        }

    private:
        T *data;
        int _size;
        int _capacity;
    };
} // arrayStudy

#endif //ARRAY_H
